TypeScript OOP ವಿನ್ಯಾಸಗಳು: ವರ್ಗ ವಿನ್ಯಾಸ ಮತ್ತು ಉತ್ತರಾಧಿಕಾರದ ತಂತ್ರಗಳಿಗೆ ಮಾರ್ಗದರ್ಶಿ

ಆಧುನಿಕ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ಜಗತ್ತಿನಲ್ಲಿ, TypeScript ಪ್ರಬಲ, ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಒಂದು ಆಧಾರಸ್ತಂಭವಾಗಿ ಹೊರಹೊಮ್ಮಿದೆ. JavaScriptನ ಮೇಲ್ಭಾಗದಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ ಇದರ ಬಲವಾದ ಟೈಪಿಂಗ್ ಸಿಸ್ಟಮ್, ದೋಷಗಳನ್ನು ಮೊದಲೇ ಪತ್ತೆಹಚ್ಚಲು ಮತ್ತು ಹೆಚ್ಚು ಊಹಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. TypeScriptನ ಶಕ್ತಿಯ ಹೃದಯಭಾಗದಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ (OOP) ತತ್ವಗಳಿಗೆ ಅದರ ಸಮಗ್ರ ಬೆಂಬಲವಿದೆ. ಆದಾಗ್ಯೂ, ವರ್ಗವನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂದು ತಿಳಿದುಕೊಳ್ಳುವುದು ಮಾತ್ರ ಸಾಕಾಗುವುದಿಲ್ಲ. TypeScript ಅನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ವರ್ಗ ವಿನ್ಯಾಸ, ಉತ್ತರಾಧಿಕಾರದ ಶ್ರೇಣಿಗಳು ಮತ್ತು ವಿಭಿನ್ನ ವಾಸ್ತುಶಿಲ್ಪದ ಮಾದರಿಗಳ ನಡುವಿನ ವಿನಿಮಯಗಳ ಆಳವಾದ ತಿಳುವಳಿಕೆ ಅಗತ್ಯವಿದೆ.

ಈ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ತಮ್ಮ ಮಧ್ಯಂತರ ಕೌಶಲ್ಯಗಳನ್ನು ಗಟ್ಟಿಗೊಳಿಸುವವರಿಂದ ಹಿಡಿದು ಅನುಭವಿ ವಾಸ್ತುಶಿಲ್ಪಿಗಳವರೆಗೆ ಜಾಗತಿಕ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ನಾವು TypeScriptನಲ್ಲಿ OOPಯ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳಿಗೆ ಆಳವಾಗಿ ಧುಮುಕುತ್ತೇವೆ, ಪರಿಣಾಮಕಾರಿ ವರ್ಗ ವಿನ್ಯಾಸ ತಂತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ ಮತ್ತು ವಯಸ್ಸಾದ ಚರ್ಚೆಯನ್ನು ಪರಿಹರಿಸುತ್ತೇವೆ: ಉತ್ತರಾಧಿಕಾರ ವಿರುದ್ಧ ಸಂಯೋಜನೆ. ಕೊನೆಯಲ್ಲಿ, ಕ್ಲೀನರ್, ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ಭವಿಷ್ಯದ-ನಿರೋಧಕ ಕೋಡ್‌ಬೇಸ್‌ಗಳಿಗೆ ಕಾರಣವಾಗುವ ತಿಳುವಳಿಕೆಯುಳ್ಳ ವಿನ್ಯಾಸ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ನಿಮಗೆ ಜ್ಞಾನವನ್ನು ನೀಡಲಾಗುವುದು.

TypeScriptನಲ್ಲಿ OOPಯ ಸ್ತಂಭಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ನಾವು ಸಂಕೀರ್ಣ ವಿನ್ಯಾಸಗಳಿಗೆ ಧುಮುಕುವ ಮೊದಲು, TypeScriptಗೆ ಅನ್ವಯಿಸುವಂತೆ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ನಾಲ್ಕು ಮೂಲಭೂತ ಸ್ತಂಭಗಳನ್ನು ಮರುಪರಿಶೀಲಿಸುವ ಮೂಲಕ ದೃಢವಾದ ಅಡಿಪಾಯವನ್ನು ಸ್ಥಾಪಿಸೋಣ.

1. ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್

ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಎಂದರೆ ವಸ್ತುವಿನ ಡೇಟಾ (ಗುಣಲಕ್ಷಣಗಳು) ಮತ್ತು ಆ ಡೇಟಾದ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವಿಧಾನಗಳನ್ನು ಒಂದೇ ಘಟಕವಾಗಿ - ಒಂದು ವರ್ಗವಾಗಿ ಕಟ್ಟುವುದು. ಇದು ವಸ್ತುವಿನ ಆಂತರಿಕ ಸ್ಥಿತಿಗೆ ನೇರ ಪ್ರವೇಶವನ್ನು ನಿರ್ಬಂಧಿಸುವುದನ್ನು ಸಹ ಒಳಗೊಂಡಿರುತ್ತದೆ. TypeScript ಇದನ್ನು ಪ್ರಾಥಮಿಕವಾಗಿ ಪ್ರವೇಶ ಮಾರ್ಪಾಡುಗಳ ಮೂಲಕ ಸಾಧಿಸುತ್ತದೆ: public, private, ಮತ್ತು protected.

ಉದಾಹರಣೆ: ಬ್ಯಾಂಕ್ ಖಾತೆಯನ್ನು ಠೇವಣಿ ಮತ್ತು ಹಿಂಪಡೆಯುವ ವಿಧಾನಗಳ ಮೂಲಕ ಮಾತ್ರ ಮಾರ್ಪಡಿಸಬಹುದು.

            class BankAccount {
  private balance: number = 0;

  constructor(initialBalance: number) {
    if (initialBalance >= 0) {
      this.balance = initialBalance;
    }
  }

  public deposit(amount: number): void {
    if (amount > 0) {
      this.balance += amount;
      console.log(`Deposited: ${amount}. New balance: ${this.balance}`);
    }
  }

  public getBalance(): number {
    // We expose the balance through a method, not directly
    return this.balance;
  }
}
            

              
                Copy
              
            
          

2. ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್

ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ ಎಂದರೆ ಸಂಕೀರ್ಣ ಅನುಷ್ಠಾನದ ವಿವರಗಳನ್ನು ಮರೆಮಾಡುವುದು ಮತ್ತು ವಸ್ತುವಿನ ಅಗತ್ಯ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಮಾತ್ರ ಬಹಿರಂಗಪಡಿಸುವುದು. ಕೆಳಗಿರುವ ಸಂಕೀರ್ಣ ಯಂತ್ರೋಪಕರಣಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಅಗತ್ಯವಿಲ್ಲದೇ ಉನ್ನತ-ಮಟ್ಟದ ಪರಿಕಲ್ಪನೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಇದು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. TypeScriptನಲ್ಲಿ, ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ abstract ತರಗತಿಗಳು ಮತ್ತು interfaces ಬಳಸಿ ಸಾಧಿಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ: ನೀವು ರಿಮೋಟ್ ಕಂಟ್ರೋಲ್ ಅನ್ನು ಬಳಸುವಾಗ, ನೀವು "ಪವರ್" ಬಟನ್ ಅನ್ನು ಒತ್ತಿರಿ. ನಿಮಗೆ ಅತಿಗೆಂಪು ಸಂಕೇತಗಳು ಅಥವಾ ಆಂತರಿಕ ಸರ್ಕ್ಯೂಟ್‌ಗಳ ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳುವ ಅಗತ್ಯವಿಲ್ಲ. ರಿಮೋಟ್ ಟಿವಿಯ ಕಾರ್ಯನಿರ್ವಹಣೆಗೆ ಅಮೂರ್ತ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.

3. ಉತ್ತರಾಧಿಕಾರ

ಉತ್ತರಾಧಿಕಾರವು ಒಂದು ಕಾರ್ಯವಿಧಾನವಾಗಿದ್ದು, ಅಲ್ಲಿ ಹೊಸ ವರ್ಗ (ಉಪವರ್ಗ ಅಥವಾ ಪಡೆದ ವರ್ಗ) ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ವರ್ಗದಿಂದ (ಸೂಪರ್‌ಕ್ಲಾಸ್ ಅಥವಾ ಬೇಸ್ ಕ್ಲಾಸ್) ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಪಡೆಯುತ್ತದೆ. ಇದು ಕೋಡ್ ಮರುಬಳಕೆಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ ಮತ್ತು ತರಗತಿಗಳ ನಡುವೆ ಸ್ಪಷ್ಟವಾದ "ಇಸ್-ಎ" ಸಂಬಂಧವನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ. TypeScript ಉತ್ತರಾಧಿಕಾರಕ್ಕಾಗಿ extends ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.

ಉದಾಹರಣೆ: `ಮ್ಯಾನೇಜರ್` ಎಂಬುದು `ಉದ್ಯೋಗಿ`ಯ ಪ್ರಕಾರ "ಇಸ್-ಎ". ಅವರು `ಹೆಸರು` ಮತ್ತು `ಗುರುತಿನ ಸಂಖ್ಯೆ`ಯಂತಹ ಸಾಮಾನ್ಯ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತಾರೆ, ಆದರೆ `ಮ್ಯಾನೇಜರ್` `ಅಧೀನರು`ಂತಹ ಹೆಚ್ಚುವರಿ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿರಬಹುದು.

            class Employee {
  constructor(public name: string, public id: number) {}

  getProfile(): string {
    return `Name: ${this.name}, ID: ${this.id}`;
  }
}

class Manager extends Employee {
  constructor(name: string, id: number, public subordinates: Employee[]) {
    super(name, id); // Call the parent constructor
  }

  // Managers can also have their own methods
  delegateTask(): void {
    console.log(`${this.name} is delegating tasks.`);
  }
}
            

              
                Copy
              
            
          

4. ಪಾಲಿಮಾರ್ಫಿಸಮ್

ಪಾಲಿಮಾರ್ಫಿಸಮ್, ಅಂದರೆ "ಹಲವು ರೂಪಗಳು," ವಿಭಿನ್ನ ತರಗತಿಗಳ ವಸ್ತುಗಳನ್ನು ಸಾಮಾನ್ಯ ಸೂಪರ್‌ಕ್ಲಾಸ್‌ನ ವಸ್ತುಗಳಾಗಿ ಪರಿಗಣಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಒಂದು ಇಂಟರ್ಫೇಸ್ ಅನ್ನು (ವಿಧಾನದ ಹೆಸರಿನಂತೆ) ವಿಭಿನ್ನ ಆಧಾರವಾಗಿರುವ ರೂಪಗಳನ್ನು (ಅನುಷ್ಠಾನಗಳು) ಪ್ರತಿನಿಧಿಸಲು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ವಿಧಾನವನ್ನು ಅತಿಕ್ರಮಿಸುವ ಮೂಲಕ ಸಾಧಿಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ: ವೃತ್ತಾಕಾರದ ವಸ್ತುವಿಗೆ ಹೋಲಿಸಿದರೆ `ಚೌಕ` ವಸ್ತುವಿಗೆ `ರೆಂಡರ್()` ವಿಧಾನವು ವಿಭಿನ್ನವಾಗಿ ವರ್ತಿಸುತ್ತದೆ, ಎರಡೂ `ಆಕಾರ`ಗಳಾಗಿದ್ದರೂ ಸಹ.

            abstract class Shape {
  abstract draw(): void; // An abstract method must be implemented by subclasses
}

class Circle extends Shape {
  draw(): void {
    console.log("Drawing a circle.");
  }
}

class Square extends Shape {
  draw(): void {
    console.log("Drawing a square.");
  }
}

function renderShapes(shapes: Shape[]): void {
  shapes.forEach(shape => shape.draw()); // Polymorphism in action!
}

const myShapes: Shape[] = [new Circle(), new Square()];
renderShapes(myShapes);
// Output:
// Drawing a circle.
// Drawing a square.
            

              
                Copy
              
            
          

ದೊಡ್ಡ ಚರ್ಚೆ: ಉತ್ತರಾಧಿಕಾರ ವಿರುದ್ಧ ಸಂಯೋಜನೆ

ಇದು OOPಯಲ್ಲಿ ಅತ್ಯಂತ ನಿರ್ಣಾಯಕ ವಿನ್ಯಾಸ ನಿರ್ಧಾರಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಆಧುನಿಕ ಸಾಫ್ಟ್‌ವೇರ್ ಎಂಜಿನಿಯರಿಂಗ್‌ನಲ್ಲಿ ಸಾಮಾನ್ಯ ಜ್ಞಾನವೆಂದರೆ "ಉತ್ತರಾಧಿಕಾರದ ಮೇಲೆ ಸಂಯೋಜನೆಗೆ ಒಲವು ತೋರಿ." ಎರಡೂ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಆಳವಾಗಿ ಅನ್ವೇಷಿಸುವ ಮೂಲಕ ಏಕೆ ಎಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳೋಣ.

ಉತ್ತರಾಧಿಕಾರ ಎಂದರೇನು? "ಇಸ್-ಎ" ಸಂಬಂಧ

ಉತ್ತರಾಧಿಕಾರವು ಬೇಸ್ ಕ್ಲಾಸ್ ಮತ್ತು ಪಡೆದ ಕ್ಲಾಸ್ ನಡುವೆ ಬಿಗಿಯಾದ ಜೋಡಣೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ನೀವು `extends` ಅನ್ನು ಬಳಸಿದಾಗ, ನೀವು ಹೊಸ ವರ್ಗವು ಮೂಲ ವರ್ಗದ ವಿಶೇಷ ಆವೃತ್ತಿಯಾಗಿದೆ ಎಂದು ಹೇಳುತ್ತಿದ್ದೀರಿ. ಸ್ಪಷ್ಟವಾದ ಕ್ರಮಾನುಗತ ಸಂಬಂಧವಿದ್ದಾಗ ಇದು ಕೋಡ್ ಮರುಬಳಕೆಗಾಗಿ ಪ್ರಬಲ ಸಾಧನವಾಗಿದೆ.

• ಪರ:
  • ಕೋಡ್ ಮರುಬಳಕೆ: ಸಾಮಾನ್ಯ ತರ್ಕವನ್ನು ಮೂಲ ತರಗತಿಯಲ್ಲಿ ಒಮ್ಮೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ.
  • ಪಾಲಿಮಾರ್ಫಿಸಮ್: ನಮ್ಮ `ಆಕಾರ` ಉದಾಹರಣೆಯಲ್ಲಿ ನೋಡಿದಂತೆ ಸೊಗಸಾದ, ಪಾಲಿಮಾರ್ಫಿಕ್ ನಡವಳಿಕೆಗೆ ಅನುಮತಿಸುತ್ತದೆ.
  • ಸ್ಪಷ್ಟ ಶ್ರೇಣಿ: ಇದು ನೈಜ-ಪ್ರಪಂಚದ, ಮೇಲಿನಿಂದ ಕೆಳಕ್ಕೆ ವರ್ಗೀಕರಣ ವ್ಯವಸ್ಥೆಯನ್ನು ಮಾದರಿಯಾಗಿಸುತ್ತದೆ.
• ಕಾನ್ಸ್:
  • ಬಿಗಿಯಾದ ಜೋಡಣೆ: ಬೇಸ್ ಕ್ಲಾಸ್‌ನಲ್ಲಿನ ಬದಲಾವಣೆಗಳು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಪಡೆದ ತರಗತಿಗಳನ್ನು ಮುರಿಯಬಹುದು. ಇದನ್ನು "ದುರ್ಬಲ ಬೇಸ್ ಕ್ಲಾಸ್ ಸಮಸ್ಯೆ" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.
  • ಶ್ರೇಣಿಯ ನರಕ: ಅತಿಯಾದ ಬಳಕೆಯು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಕಷ್ಟಕರವಾದ ಆಳವಾದ, ಸಂಕೀರ್ಣ ಮತ್ತು ಕಟ್ಟುನಿಟ್ಟಾದ ಉತ್ತರಾಧಿಕಾರದ ಸರಪಳಿಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.
  • ಹೊಂದಿಕೊಳ್ಳುವಂತಿಲ್ಲ: TypeScriptನಲ್ಲಿ ಒಂದು ವರ್ಗವು ಕೇವಲ ಒಂದು ಇತರ ವರ್ಗದಿಂದ ಮಾತ್ರ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯಬಹುದು (ಏಕ ಉತ್ತರಾಧಿಕಾರ), ಇದು ಸೀಮಿತಗೊಳಿಸಬಹುದು. ನೀವು ಬಹು, ಸಂಬಂಧವಿಲ್ಲದ ತರಗತಿಗಳಿಂದ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಉತ್ತರಾಧಿಕಾರವು ಉತ್ತಮ ಆಯ್ಕೆಯಾದಾಗ?

ಸಂಬಂಧವು ನಿಜವಾಗಿಯೂ "ಇಸ್-ಎ" ಆಗಿರುವಾಗ ಮತ್ತು ಸ್ಥಿರವಾಗಿದ್ದಾಗ ಮತ್ತು ಬದಲಾಗುವ ಸಾಧ್ಯತೆಯಿಲ್ಲದಿದ್ದಾಗ ಉತ್ತರಾಧಿಕಾರವನ್ನು ಬಳಸಿ. ಉದಾಹರಣೆಗೆ, `ಚೆಕ್ಕಿಂಗ್‌ಖಾತೆ` ಮತ್ತು `ಉಳಿತಾಯಖಾತೆ` ಎರಡೂ ಮೂಲಭೂತವಾಗಿ `ಬ್ಯಾಂಕ್‌ಖಾತೆ`ಯ ವಿಧಗಳಾಗಿವೆ. ಈ ಶ್ರೇಣಿಯು ಅರ್ಥಪೂರ್ಣವಾಗಿದೆ ಮತ್ತು ಮರುರೂಪಿಸುವ ಸಾಧ್ಯತೆಯಿಲ್ಲ.

ಸಂಯೋಜನೆ ಎಂದರೇನು? "ಹ್ಯಾಸ್-ಎ" ಸಂಬಂಧ

ಸಂಯೋಜನೆಯು ಸಣ್ಣ, ಸ್ವತಂತ್ರ ವಸ್ತುಗಳಿಂದ ಸಂಕೀರ್ಣ ವಸ್ತುಗಳನ್ನು ನಿರ್ಮಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಒಂದು ವರ್ಗವು ಬೇರೆಯೇನೋ ಆಗುವುದಕ್ಕಿಂತ, ಅದಕ್ಕೆ ಅಗತ್ಯವಾದ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುವ ಇತರ ವಸ್ತುಗಳು ಇರುತ್ತವೆ. ಇದು ಸಡಿಲವಾದ ಜೋಡಣೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ವರ್ಗವು ಸಂಯೋಜಿತ ವಸ್ತುಗಳ ಸಾರ್ವಜನಿಕ ಇಂಟರ್ಫೇಸ್‌ನೊಂದಿಗೆ ಮಾತ್ರ ಸಂವಹನ ನಡೆಸುತ್ತದೆ.

• ಪರ:
  • ಹೊಂದಿಕೊಳ್ಳುವಿಕೆ: ಸಂಯೋಜಿತ ವಸ್ತುಗಳನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ ಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಬದಲಾಯಿಸಬಹುದು.
  • ಸಡಿಲವಾದ ಜೋಡಣೆ: ಹೊಂದಿರುವ ವರ್ಗವು ಅದು ಬಳಸುವ ಘಟಕಗಳ ಒಳ ಕಾರ್ಯನಿರ್ವಹಣೆಯ ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳಬೇಕಾಗಿಲ್ಲ. ಇದು ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.
  • ಶ್ರೇಣಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ: ನೀವು ಸಿಕ್ಕಿಹಾಕಿಕೊಂಡ ಉತ್ತರಾಧಿಕಾರದ ಮರವನ್ನು ರಚಿಸದೆ ವಿವಿಧ ಮೂಲಗಳಿಂದ ಕಾರ್ಯಗಳನ್ನು ಸಂಯೋಜಿಸಬಹುದು.
  • ಸ್ಪಷ್ಟ ಜವಾಬ್ದಾರಿಗಳು: ಪ್ರತಿಯೊಂದು ಘಟಕ ವರ್ಗವು ಏಕ ಜವಾಬ್ದಾರಿ ತತ್ವಕ್ಕೆ ಬದ್ಧವಾಗಿರಬಹುದು.
• ಕಾನ್ಸ್:
  • ಹೆಚ್ಚಿನ ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್: ಸರಳವಾದ ಉತ್ತರಾಧಿಕಾರದ ಮಾದರಿಗೆ ಹೋಲಿಸಿದರೆ ವಿಭಿನ್ನ ಘಟಕಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸೇರಿಸಲು ಕೆಲವೊಮ್ಮೆ ಹೆಚ್ಚಿನ ಕೋಡ್ ಅಗತ್ಯವಾಗಬಹುದು.
  • ಕ್ರಮಾನುಗತಗಳಿಗೆ ಕಡಿಮೆ ಅರ್ಥಗರ್ಭಿತ: ಇದು ನೈಸರ್ಗಿಕ ವರ್ಗೀಕರಣಗಳನ್ನು ಉತ್ತರಾಧಿಕಾರ ಮಾಡುವಷ್ಟು ನೇರವಾಗಿ ಮಾದರಿಯಾಗಿಸುವುದಿಲ್ಲ.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ: ಕಾರು

`ಕಾರು` ಸಂಯೋಜನೆಗೆ ಪರಿಪೂರ್ಣ ಉದಾಹರಣೆಯಾಗಿದೆ. `ಕಾರು` ಎಂದರೆ `ಎಂಜಿನ್` ಪ್ರಕಾರವಲ್ಲ, ಅಥವಾ `ಚಕ್ರ`ದ ಪ್ರಕಾರವೂ ಅಲ್ಲ. ಬದಲಾಗಿ, `ಕಾರು` ಒಂದು `ಎಂಜಿನ್` ಅನ್ನು ಹೊಂದಿದೆ ಮತ್ತು `ಚಕ್ರಗಳು` ಅನ್ನು ಹೊಂದಿದೆ.

            // Component classes
class Engine {
  start() {
    console.log("Engine starting...");
  }
}

class GPS {
  navigate(destination: string) {
    console.log(`Navigating to ${destination}...`);
  }
}

// The composite class
class Car {
  private readonly engine: Engine;
  private readonly gps: GPS;

  constructor() {
    // The Car creates its own parts
    this.engine = new Engine();
    this.gps = new GPS();
  }

  driveTo(destination: string) {
    this.engine.start();
    this.gps.navigate(destination);
    console.log("Car is on its way.");
  }
}

const myCar = new Car();
myCar.driveTo("New York City");
            

              
                Copy
              
            
          

ಈ ವಿನ್ಯಾಸವು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವಂತಿದೆ. ನಾವು `ಎಲೆಕ್ಟ್ರಿಕ್ ಎಂಜಿನ್`ನೊಂದಿಗೆ `ಕಾರು` ಅನ್ನು ರಚಿಸಲು ಬಯಸಿದರೆ, ನಮಗೆ ಹೊಸ ಉತ್ತರಾಧಿಕಾರದ ಸರಪಳಿಯ ಅಗತ್ಯವಿಲ್ಲ. `ಕಾರು`ಗೆ ಅದರ ಘಟಕಗಳನ್ನು ಒದಗಿಸಲು ನಾವು ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಅನ್ನು ಬಳಸಬಹುದು, ಇದು ಇನ್ನಷ್ಟು ಮಾಡ್ಯುಲರ್ ಆಗಿರುತ್ತದೆ.

            interface IEngine {
  start(): void;
}

class PetrolEngine implements IEngine {
  start() { console.log("Petrol engine starting..."); }
}

class ElectricEngine implements IEngine {
  start() { console.log("Silent electric engine starting..."); }
}

class AdvancedCar {
  // The car depends on an abstraction (interface), not a concrete class
  constructor(private engine: IEngine) {}

  startJourney() {
    this.engine.start();
    console.log("Journey has begun.");
  }
}

const tesla = new AdvancedCar(new ElectricEngine());
tesla.startJourney();

const ford = new AdvancedCar(new PetrolEngine());
ford.startJourney();
            

              
                Copy
              
            
          

TypeScriptನಲ್ಲಿ ಸುಧಾರಿತ ತಂತ್ರಗಳು ಮತ್ತು ವಿನ್ಯಾಸಗಳು

ಉತ್ತರಾಧಿಕಾರ ಮತ್ತು ಸಂಯೋಜನೆಯ ನಡುವಿನ ಮೂಲಭೂತ ಆಯ್ಕೆಯಾಚೆಗೆ, ಅತ್ಯಾಧುನಿಕ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ವರ್ಗ ವಿನ್ಯಾಸಗಳನ್ನು ರಚಿಸಲು TypeScript ಪ್ರಬಲ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

1. ಅಮೂರ್ತ ವರ್ಗಗಳು: ಉತ್ತರಾಧಿಕಾರಕ್ಕಾಗಿ ನೀಲನಕ್ಷೆ

ನೀವು ಬಲವಾದ "ಇಸ್-ಎ" ಸಂಬಂಧವನ್ನು ಹೊಂದಿರುವಾಗ ಮತ್ತು ಮೂಲ ತರಗತಿಗಳನ್ನು ತಮ್ಮದೇ ಆದ ಮೇಲೆ ಸ್ಥಾಪಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಯಸಿದಾಗ, `abstract` ತರಗತಿಗಳನ್ನು ಬಳಸಿ. ಅವು ನೀಲನಕ್ಷೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಸಾಮಾನ್ಯ ವಿಧಾನಗಳು ಮತ್ತು ಗುಣಲಕ್ಷಣಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತವೆ ಮತ್ತು ಪಡೆದ ತರಗತಿಗಳು ಖಂಡಿತವಾಗಿ ಅನುಷ್ಠಾನಗೊಳಿಸಬೇಕಾದ `abstract` ವಿಧಾನಗಳನ್ನು ಘೋಷಿಸಬಹುದು.

ಬಳಕೆಯ ಸಂದರ್ಭ: ಪಾವತಿ ಪ್ರಕ್ರಿಯೆ ವ್ಯವಸ್ಥೆ. ಪ್ರತಿಯೊಂದು ಗೇಟ್‌ವೇಯು `pay()` ಮತ್ತು `refund()` ವಿಧಾನಗಳನ್ನು ಹೊಂದಿರಬೇಕು ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ, ಆದರೆ ಅನುಷ್ಠಾನವು ಪ್ರತಿ ಪೂರೈಕೆದಾರರಿಗೆ ನಿರ್ದಿಷ್ಟವಾಗಿರುತ್ತದೆ (ಉದಾ., ಸ್ಟ್ರೈಪ್, ಪೇಪಾಲ್).

            abstract class PaymentGateway {
  constructor(public apiKey: string) {}

  // A concrete method shared by all subclasses
  protected connect(): void {
    console.log("Connecting to payment service...");
  }

  // Abstract methods that subclasses must implement
  abstract processPayment(amount: number): boolean;
  abstract issueRefund(transactionId: string): boolean;
}

class StripeGateway extends PaymentGateway {
  processPayment(amount: number): boolean {
    this.connect();
    console.log(`Processing ${amount} via Stripe.`);
    return true;
  }

  issueRefund(transactionId: string): boolean {
    console.log(`Refunding transaction ${transactionId} via Stripe.`);
    return true;
  }
}

// const gateway = new PaymentGateway("key"); // Error: Cannot create an instance of an abstract class.
const stripe = new StripeGateway("sk_test_123");
stripe.processPayment(100);
            

              
                Copy
              
            
          

2. ಇಂಟರ್ಫೇಸ್‌ಗಳು: ನಡವಳಿಕೆಗಾಗಿ ಒಪ್ಪಂದಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು

TypeScriptನಲ್ಲಿ ಇಂಟರ್ಫೇಸ್‌ಗಳು ವರ್ಗದ ಆಕಾರಕ್ಕಾಗಿ ಒಪ್ಪಂದವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ. ಅವು ಒಂದು ವರ್ಗವು ಹೊಂದಿರಬೇಕಾದ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತವೆ, ಆದರೆ ಅವು ಯಾವುದೇ ಅನುಷ್ಠಾನವನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ. ಒಂದು ವರ್ಗವು ಬಹು ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು `ಅನುಷ್ಠಾನಗೊಳಿಸಬಹುದು`, ಅವುಗಳನ್ನು ಸಂಯೋಜಿತ ಮತ್ತು ಬೇರ್ಪಟ್ಟ ವಿನ್ಯಾಸದ ಮೂಲಾಧಾರವನ್ನಾಗಿ ಮಾಡುತ್ತದೆ.

ಇಂಟರ್ಫೇಸ್ ವಿರುದ್ಧ ಅಮೂರ್ತ ವರ್ಗ

• ನೀವು ಹಲವಾರು ನಿಕಟ ಸಂಬಂಧಿತ ತರಗತಿಗಳ ನಡುವೆ ಅನುಷ್ಠಾನಗೊಳಿಸಿದ ಕೋಡ್ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಬಯಸಿದಾಗ ಅಮೂರ್ತ ವರ್ಗವನ್ನು ಬಳಸಿ.
• ವಿಭಿನ್ನ, ಸಂಬಂಧವಿಲ್ಲದ ತರಗತಿಗಳಿಂದ ಅನುಷ್ಠಾನಗೊಳಿಸಬಹುದಾದ ನಡವಳಿಕೆಗಾಗಿ ಒಪ್ಪಂದವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನೀವು ಬಯಸಿದಾಗ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಬಳಸಿ.

ಬಳಕೆಯ ಸಂದರ್ಭ: ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಅನೇಕ ವಿಭಿನ್ನ ವಸ್ತುಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ ಸರಣೀಕರಿಸಬೇಕಾಗಬಹುದು (ಉದಾ., ಲಾಗಿಂಗ್ ಅಥವಾ ಸಂಗ್ರಹಣೆಗಾಗಿ). ಈ ವಸ್ತುಗಳು (`ಬಳಕೆದಾರ`, `ಉತ್ಪನ್ನ`, `ಆದೇಶ`) ಸಂಬಂಧವಿಲ್ಲದಿದ್ದರೂ ಸಾಮಾನ್ಯ ಸಾಮರ್ಥ್ಯವನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ.

            interface ISerializable {
  serialize(): string;
}

class User implements ISerializable {
  constructor(public id: number, public name: string) {}

  serialize(): string {
    return JSON.stringify({ id: this.id, name: this.name });
  }
}

class Product implements ISerializable {
  constructor(public sku: string, public price: number) {}

  serialize(): string {
    return JSON.stringify({ sku: this.sku, price: this.price });
  }
}

function logItems(items: ISerializable[]): void {
  items.forEach(item => {
    console.log("Serialized item:", item.serialize());
  });
}

const user = new User(1, "Alice");
const product = new Product("TSHIRT-RED", 19.99);
logItems([user, product]);
            

              
                Copy
              
            
          

3. ಮಿಕ್ಸಿನ್‌ಗಳು: ಕೋಡ್ ಮರುಬಳಕೆಗೆ ಸಂಯೋಜನಾ ವಿಧಾನ

TypeScript ಏಕ ಉತ್ತರಾಧಿಕಾರವನ್ನು ಮಾತ್ರ ಅನುಮತಿಸುವುದರಿಂದ, ನೀವು ಬಹು ಮೂಲಗಳಿಂದ ಕೋಡ್ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡಲು ಬಯಸಿದರೆ ಏನು? ಇಲ್ಲಿಯೇ ಮಿಕ್ಸಿನ್ ಮಾದರಿಯು ಬರುತ್ತದೆ. ಮಿಕ್ಸಿನ್‌ಗಳು ಒಂದು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಹೊಸ ಕ್ರಿಯಾತ್ಮಕತೆಯೊಂದಿಗೆ ಅದನ್ನು ವಿಸ್ತರಿಸುವ ಹೊಸ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಕಾರ್ಯಗಳಾಗಿವೆ. ಇದು ಸಂಯೋಜನೆಯ ಒಂದು ರೂಪವಾಗಿದ್ದು, ಇದು ಒಂದು ವರ್ಗಕ್ಕೆ ಸಾಮರ್ಥ್ಯಗಳನ್ನು "ಮಿಕ್ಸ್ ಇನ್" ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಬಳಕೆಯ ಸಂದರ್ಭ: ನೀವು ಬಹು ಮಾದರಿ ತರಗತಿಗಳಿಗೆ `ಟೈಮ್‌ಸ್ಟಾಂಪ್` (`createdAt`, `updatedAt` ನೊಂದಿಗೆ) ಮತ್ತು `ಸಾಫ್ಟ್‌ಡಿಲೀಟಬಲ್` ( `deletedAt` ಆಸ್ತಿ ಮತ್ತು `softDelete()` ವಿಧಾನದೊಂದಿಗೆ) ನಡವಳಿಕೆಗಳನ್ನು ಸೇರಿಸಲು ಬಯಸುತ್ತೀರಿ.

            // A Type helper for mixins
type Constructor = new (...args: any[]) => T;

// Timestamp Mixin
function Timestamped(Base: TBase) {
  return class extends Base {
    createdAt: Date = new Date();
    updatedAt: Date = new Date();
  };
}

// SoftDeletable Mixin
function SoftDeletable(Base: TBase) {
  return class extends Base {
    deletedAt: Date | null = null;

    softDelete() {
      this.deletedAt = new Date();
      console.log("Item has been soft deleted.");
    }
  };
}

// Base class
class DocumentModel {
  constructor(public title: string) {}
}

// Create a new class by composing mixins
const UserAccountModel = SoftDeletable(Timestamped(DocumentModel));

const userAccount = new UserAccountModel("My User Account");
console.log(userAccount.title);
console.log(userAccount.createdAt);
userAccount.softDelete();
console.log(userAccount.deletedAt);
            

              
                Copy
              
            
          

ತೀರ್ಮಾನ: ಭವಿಷ್ಯದ-ನಿರೋಧಕ TypeScript ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವುದು

TypeScriptನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದರಿಂದ ವಿನ್ಯಾಸ ತತ್ವಶಾಸ್ತ್ರವನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವವರೆಗಿನ ಪ್ರಯಾಣವಾಗಿದೆ. ವರ್ಗ ರಚನೆ, ಉತ್ತರಾಧಿಕಾರ ಮತ್ತು ಸಂಯೋಜನೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ನೀವು ಮಾಡುವ ಆಯ್ಕೆಗಳು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ದೀರ್ಘಕಾಲೀನ ಆರೋಗ್ಯದ ಮೇಲೆ ಆಳವಾದ ಪರಿಣಾಮ ಬೀರುತ್ತವೆ.

ನಿಮ್ಮ ಜಾಗತಿಕ ಅಭಿವೃದ್ಧಿ ಅಭ್ಯಾಸಕ್ಕಾಗಿ ಪ್ರಮುಖ ವಿಷಯಗಳು ಇಲ್ಲಿವೆ:

1. ಸ್ತಂಭಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ: ಎನ್‌ಕ್ಯಾಪ್ಸುಲೇಶನ್, ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್, ಉತ್ತರಾಧಿಕಾರ ಮತ್ತು ಪಾಲಿಮಾರ್ಫಿಸಮ್ ಬಗ್ಗೆ ನಿಮಗೆ ಗಟ್ಟಿಯಾದ ಹಿಡಿತವಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಅವು OOPಯ ಶಬ್ದಕೋಶ.
2. ಉತ್ತರಾಧಿಕಾರದ ಮೇಲೆ ಸಂಯೋಜನೆಗೆ ಒಲವು ತೋರಿ: ಈ ತತ್ವವು ನಿಮ್ಮನ್ನು ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ, ಮಾಡ್ಯುಲರ್ ಮತ್ತು ಪರೀಕ್ಷಿಸಬಹುದಾದ ಕೋಡ್‌ಗೆ ಕರೆದೊಯ್ಯುತ್ತದೆ. ಸಂಯೋಜನೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಸ್ಪಷ್ಟವಾದ, ಸ್ಥಿರವಾದ "ಇಸ್-ಎ" ಸಂಬಂಧವಿದ್ದಾಗ ಮಾತ್ರ ಉತ್ತರಾಧಿಕಾರಕ್ಕಾಗಿ ತಲುಪಿ.
3. ಕೆಲಸಕ್ಕಾಗಿ ಸರಿಯಾದ ಸಾಧನವನ್ನು ಬಳಸಿ:
   • ಸ್ಥಿರ ಶ್ರೇಣಿಯಲ್ಲಿ ನಿಜವಾದ ಪರಿಣತಿ ಮತ್ತು ಕೋಡ್ ಹಂಚಿಕೆಗಾಗಿ ಉತ್ತರಾಧಿಕಾರವನ್ನು ಬಳಸಿ.
   • ಕೆಲವು ಅನುಷ್ಠಾನವನ್ನು ಹಂಚಿಕೊಳ್ಳುವಾಗ ಒಪ್ಪಂದವನ್ನು ಜಾರಿಗೊಳಿಸುವ ತರಗತಿಗಳ ಕುಟುಂಬಕ್ಕೆ ಸಾಮಾನ್ಯ ಆಧಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅಮೂರ್ತ ತರಗತಿಗಳನ್ನು ಬಳಸಿ.
   • ಯಾವುದೇ ವರ್ಗದಿಂದ ಅನುಷ್ಠಾನಗೊಳಿಸಬಹುದಾದ ನಡವಳಿಕೆಗಾಗಿ ಒಪ್ಪಂದಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ಬಳಸಿ, ವಿಪರೀತ ಬೇರ್ಪಡುವಿಕೆಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ.
   • ನೀವು ಬಹು ಮೂಲಗಳಿಂದ ಒಂದು ವರ್ಗಕ್ಕೆ ಕಾರ್ಯಗಳನ್ನು ಸಂಯೋಜಿಸಬೇಕಾದಾಗ ಮಿಕ್ಸಿನ್‌ಗಳನ್ನು ಬಳಸಿ, ಏಕ ಉತ್ತರಾಧಿಕಾರದ ಮಿತಿಗಳನ್ನು ಮೀರುತ್ತದೆ.

ಈ ವಿನ್ಯಾಸಗಳ ಬಗ್ಗೆ ನಿರ್ಣಾಯಕವಾಗಿ ಯೋಚಿಸುವ ಮೂಲಕ ಮತ್ತು ಅವುಗಳ ವಿನಿಮಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು TypeScript ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ವಾಸ್ತುಶಿಲ್ಪಗೊಳಿಸಬಹುದು, ಅದು ಇಂದು ಶಕ್ತಿಯುತ ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುವುದಲ್ಲದೆ, ನೀವು ಅಥವಾ ನಿಮ್ಮ ತಂಡವು ಜಗತ್ತಿನಲ್ಲಿ ಎಲ್ಲೇ ಇದ್ದರೂ ವರ್ಷಗಳವರೆಗೆ ಅಳವಡಿಸಿಕೊಳ್ಳಲು, ವಿಸ್ತರಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿದೆ.